
搜索文档...
文档首页
核心文档
快速起步
CLI 快速起步
开发指南
API参考手册
附加文档
教程
高级文档
动画
属性型指令
浏览器支持
组件样式
部署
多级注入器
响应式表单
HTTP 客户端
生命周期钩子
Angular模块 (NgModule)
npm 包
管道
路由与导航
安全
搭建剖析
结构型指令
测试
TypeScript 配置
从 AngularJS 升级
Webpack 简介
烹饪宝典
Angular for TypeScript
生命周期钩子
Angular 调用指令和组件的生命周期钩子函数，包括它的创建、变更和销毁时。
Us
每个组件都有一个被Angular管理的生命周期。

Angular创建它，渲染它，创建并渲染它的子组件，在它被绑定的属性发生变化时检查它，并在它从DOM中被移除前销毁它。

Angular提供了生命周期钩子，把这些关键生命时刻暴露出来，赋予我们在它们发生时采取行动的能力。

除了那些组件内容和视图相关的钩子外,指令有相同生命周期钩子。



目录

组件生命周期概览
生命周期的顺序
接口是可选的（理论上）
其它Angular生命周期钩子
生命周期范例
Peek-a-boo：所有钩子
监听OnInit和OnDestroy
OnInit
OnDestroy
OnChanges
DoCheck
AfterView
遵循单向数据流规则
AfterContent
内容投影
AfterContent钩子
非单向数据流下AfterContent的注意事项
试一试在线例子 / 可下载的例子。

组件生命周期钩子概览

指令和组件的实例有一个生命周期：新建、更新和销毁。 通过实现一个或多个Angular core库里定义的生命周期钩子接口，开发者可以介入该生命周期中的这些关键时刻。

每个接口都有唯一的一个钩子方法，它们的名字是由接口名再加上ng前缀构成的。比如，OnInit接口的钩子方法叫做ngOnInit， Angular在创建组件后立刻调用它，：

peek-a-boo.component.ts (excerpt)
Copy Code
export class PeekABoo implements OnInit {
  constructor(private logger: LoggerService) { }

  // implement OnInit's `ngOnInit` method
  ngOnInit() { this.logIt(`OnInit`); }

  logIt(msg: string) {
    this.logger.log(`#${nextId++} ${msg}`);
  }
}
没有指令或者组件会实现所有这些接口，并且有些钩子只对组件有意义。只有在指令/组件中定义过的那些钩子方法才会被Angular调用。

生命周期的顺序

当Angular使用构造函数新建一个组件或指令后，就会按下面的顺序在特定时刻调用这些生命周期钩子方法：

钩子
目的和时机
ngOnChanges()	
当Angular（重新）设置数据绑定输入属性时响应。 该方法接受当前和上一属性值的SimpleChanges对象
当被绑定的输入属性的值发生变化时调用，首次调用一定会发生在ngOnInit()之前。
ngOnInit()	
在Angular第一次显示数据绑定和设置指令/组件的输入属性之后，初始化指令/组件。
在第一轮ngOnChanges()完成之后调用，只调用一次。
ngDoCheck()	
检测，并在发生Angular无法或不愿意自己检测的变化时作出反应。
在每个Angular变更检测周期中调用，ngOnChanges()和ngOnInit()之后。
ngAfterContentInit()	
当把内容投影进组件之后调用。
第一次ngDoCheck()之后调用，只调用一次。
只适用于组件。
ngAfterContentChecked()	
每次完成被投影组件内容的变更检测之后调用。
ngAfterContentInit()和每次ngDoCheck()之后调用
只适合组件。
ngAfterViewInit()	
初始化完组件视图及其子视图之后调用。
第一次ngAfterContentChecked()之后调用，只调用一次。
只适合组件。
ngAfterViewChecked()	
每次做完组件视图和子视图的变更检测之后调用。
ngAfterViewInit()和每次ngAfterContentChecked()之后调用。
只适合组件。
ngOnDestroy	
当Angular每次销毁指令/组件之前调用并清扫。 在这儿反订阅可观察对象和分离事件处理器，以防内存泄漏。
在Angular销毁指令/组件之前调用。
接口是可选的(理论上)？

从纯技术的角度讲，接口对JavaScript和TypeScript的开发者都是可选的。JavaScript语言本身没有接口。 Angular在运行时看不到TypeScript接口，因为它们在编译为JavaScript的时候已经消失了。

幸运的是，它们并不是必须的。

我们并不需要在指令和组件上添加生命周期钩子接口就能获得钩子带来的好处。

Angular会去检测我们的指令和组件的类，一旦发现钩子方法被定义了，就调用它们。 Agnular会找到并调用像ngOnInit()这样的钩子方法，有没有接口无所谓。

虽然如此，我们还是强烈建议你在TypeScript指令类中添加接口，以获得强类型和IDE等编辑器带来的好处。

其它生命周期钩子

Angular的其它子系统除了有这些组件钩子外，还可能有它们自己的生命周期钩子。

第三方库也可能会实现它们自己的钩子，以便让我们这些开发者在使用时能做更多的控制。

生命周期练习

在线例子 / 可下载的例子通过在受控于根组件AppComponent的一些组件上进行的一系列练习，演示了生命周期钩子的运作方式。

它们遵循了一个常用的模式：用子组件演示一个或多个生命周期钩子方法，而父组件被当作该子组件的测试台。

下面是每个练习简短的描述：

组件
描述
Peek-a-boo	
展示每个生命周期钩子，每个钩子方法都会在屏幕上显示一条日志。
Spy	
指令也同样有生命周期钩子。我们新建了一个SpyDirective，利用ngOnInit和ngOnDestroy钩子，在它所监视的每个元素被创建或销毁时输出日志。
本例把SpyDirective应用到父组件里的ngFor英雄重复器(repeater)的<div>里面。
OnChanges	
这里将会看到：每当组件的输入属性发生变化时，Angular会如何以changes对象作为参数去调用ngOnChanges()钩子。 展示了该如何理解和使用changes对象。
DoCheck	
实现了一个ngDoCheck()方法，通过它可以自定义变更检测逻辑。 这里将会看到：Angular会用什么频度调用这个钩子，监视它的变化，并把这些变化输出成一条日志。
AfterView	
显示Angular中的视图所指的是什么。 演示了ngAfterViewInit和ngAfterViewChecked钩子。
AfterContent	
展示如何把外部内容投影进组件中，以及如何区分“投影进来的内容”和“组件的子视图”。 演示了ngAfterContentInit和ngAfterContentChecked钩子。
计数器
演示了组件和指令的组合，它们各自有自己的钩子。
在这个例子中，每当父组件递增它的输入属性counter时，CounterComponent就会通过ngOnChanges记录一条变更。 同时，我们还把前一个例子中的SpyDirective用在CounterComponent上，来提供日志，可以同时观察到日志的创建和销毁过程。
接下来，我们将详细讨论这些练习。

Peek-a-boo：全部钩子

PeekABooComponent组件演示了组件中所有可能存在的钩子。

你可能很少、或者永远不会像这里一样实现所有这些接口。 我们之所以在peek-a-boo中这么做，只是为了观看Angular是如何按照期望的顺序调用这些钩子的。

用户点击Create...按钮，然后点击Destroy...按钮后，日志的状态如下图所示：

Peek-a-boo
日志信息的日志和所规定的钩子调用顺序是一致的： OnChanges、OnInit、DoCheck (3x)、AfterContentInit、AfterContentChecked (3x)、 AfterViewInit、AfterViewChecked (3x)和OnDestroy

构造函数本质上不应该算作Angular的钩子。 记录确认了在创建期间那些输入属性(这里是name属性)没有被赋值。
如果我们点击Update Hero按钮，就会看到另一个OnChanges和至少两组DoCheck、AfterContentChecked和AfterViewChecked钩子。 显然，这三种钩子被触发了很多次，所以我们必须让这三种钩子里的逻辑尽可能的精简！

下一个例子就聚焦于这些钩子的细节上。

窥探OnInit和OnDestroy

潜入这两个spy钩子来发现一个元素是什么时候被初始化或者销毁的。

指令是一种完美的渗透方式，我们的英雄永远不会知道该指令的存在。

不开玩笑了，注意下面两个关键点：
就像对组件一样，Angular也会对指令调用这些钩子方法。
一个侦探(spy)指令可以让我们在无法直接修改DOM对象实现代码的情况下，透视其内部细节。 显然，你不能修改一个原生<div>元素的实现代码。 你同样不能修改第三方组件。 但我们用一个指令就能监视它们了。
我们这个鬼鬼祟祟的侦探指令很简单，几乎完全由ngOnInit()和ngOnDestroy()钩子组成，它通过一个注入进来的LoggerService来把消息记录到父组件中去。

Copy Code
// Spy on any element to which it is applied.
// Usage: <div mySpy>...</div>
@Directive({selector: '[mySpy]'})
export class SpyDirective implements OnInit, OnDestroy {

  constructor(private logger: LoggerService) { }

  ngOnInit()    { this.logIt(`onInit`); }

  ngOnDestroy() { this.logIt(`onDestroy`); }

  private logIt(msg: string) {
    this.logger.log(`Spy #${nextId++} ${msg}`);
  }
}
我们可以把这个侦探指令写到任何原生元素或组件元素上，它将与所在的组件同时初始化和销毁。 下面是把它附加到用来重复显示英雄数据的这个<div>上。

Copy Code
<div *ngFor="let hero of heroes" mySpy class="heroes">
  {{hero}}
</div>
每个“侦探”的出生和死亡也同时标记出了存放英雄的那个<div>的出生和死亡。钩子记录中的结构是这样的：

Spy Directive
添加一个英雄就会产生一个新的英雄<div>。侦探的ngOnInit()记录下了这个事件。

Reset按钮清除了这个heroes列表。 Angular从DOM中移除了所有英雄的div，并且同时销毁了附加在这些div上的侦探指令。 侦探的ngOnDestroy()方法汇报了它自己的临终时刻。

在真实的应用程序中，ngOnInit()和ngOnDestroy()方法扮演着更重要的角色。

OnInit()
使用ngOnInit()有两个原因：

在构造函数之后马上执行复杂的初始化逻辑
在Angular设置完输入属性之后，对该组件进行准备。
有经验的开发者认同组件的构建应该很便宜和安全。

Misko Hevery，Angular项目的头，在这里解释了你为什么应该避免复杂的构造函数逻辑。
不要在组件的构造函数中获取数据？ 在测试环境下新建组件时或在我们决定显示它之前，我们不应该担心它会尝试联系远程服务器。 构造函数中除了使用简单的值对局部变量进行初始化之外，什么都不应该做。

ngOnInit()是组件获取初始数据的好地方。指南和HTTP章讲解了如何这样做。

另外还要记住，在指令的构造函数完成之前，那些被绑定的输入属性还都没有值。 如果我们需要基于这些属性的值来初始化这个指令，这种情况就会出问题。 而当ngOnInit()执行的时候，这些属性都已经被正确的赋值过了。

我们访问这些属性的第一次机会，实际上是ngOnChanges()方法，Angular会在ngOnInit()之前调用它。 但是在那之后，Angular还会调用ngOnChanges()很多次。而ngOnInit()只会被调用一次。
你可以信任Angular会在创建组件后立刻调用ngOnInit()方法。 这里是放置复杂初始化逻辑的好地方。

OnDestroy()
一些清理逻辑必须在Angular销毁指令之前运行，把它们放在ngOnDestroy()中。

这是在该组件消失之前，可用来通知应用程序中其它部分的最后一个时间点。

这里是用来释放那些不会被垃圾收集器自动回收的各类资源的地方。 取消那些对可观察对象和DOM事件的订阅。停止定时器。注销该指令曾注册到全局服务或应用级服务中的各种回调函数。 如果不这么做，就会有导致内存泄露的风险。

OnChanges()

在这个例子中，我们监听了OnChanges钩子。 一旦检测到该组件(或指令)的输入属性发生了变化，Angular就会调用它的ngOnChanges()方法。

本例监控OnChanges钩子。

on-changes.component.ts (excerpt)
Copy Code
ngOnChanges(changes: SimpleChanges) {
  for (let propName in changes) {
    let chng = changes[propName];
    let cur  = JSON.stringify(chng.currentValue);
    let prev = JSON.stringify(chng.previousValue);
    this.changeLog.push(`${propName}: currentValue = ${cur}, previousValue = ${prev}`);
  }
}
ngOnChanges()方法获取了一个对象，它把每个发生变化的属性名都映射到了一个SimpleChange对象， 该对象中有属性的当前值和前一个值。我们在这些发生了变化的属性上进行迭代，并记录它们。

这个例子中的OnChangesComponent组件有两个输入属性：hero和power。

Copy Code
@Input() hero: Hero;
@Input() power: string;
宿主OnChangesParentComponent绑定了它们，就像这样：

Copy Code
<on-changes [hero]="hero" [power]="power"></on-changes>
下面是此例子中的当用户做出更改时的操作演示：

OnChanges
当power属性的字符串值变化时，相应的日志就出现了。 但是ngOnChanges并没有捕捉到hero.name的变化。 这是第一个意外。

Angular只会在输入属性的值变化时调用这个钩子。 而hero属性的值是一个到英雄对象的引用。 Angular不会关注这个英雄对象的name属性的变化。 这个英雄对象的引用没有发生变化，于是从Angular的视角看来，也就没有什么需要报告的变化了。

DoCheck()

使用DoCheck钩子来检测那些Angular自身无法捕获的变更并采取行动。

用这个方法来检测那些被Angular忽略的更改。
DoCheck范例通过下面的ngDoCheck()实现扩展了OnChanges范例：

DoCheckComponent (ngDoCheck)
Copy Code
ngDoCheck() {

  if (this.hero.name !== this.oldHeroName) {
    this.changeDetected = true;
    this.changeLog.push(`DoCheck: Hero name changed to "${this.hero.name}" from "${this.oldHeroName}"`);
    this.oldHeroName = this.hero.name;
  }

  if (this.power !== this.oldPower) {
    this.changeDetected = true;
    this.changeLog.push(`DoCheck: Power changed to "${this.power}" from "${this.oldPower}"`);
    this.oldPower = this.power;
  }

  if (this.changeDetected) {
      this.noChangeCount = 0;
  } else {
      // log that hook was called when there was no relevant change.
      let count = this.noChangeCount += 1;
      let noChangeMsg = `DoCheck called ${count}x when no change to hero or power`;
      if (count === 1) {
        // add new "no change" message
        this.changeLog.push(noChangeMsg);
      } else {
        // update last "no change" message
        this.changeLog[this.changeLog.length - 1] = noChangeMsg;
      }
  }

  this.changeDetected = false;
}
该代码检测一些相关的值，捕获当前值并与以前的值进行比较。 当英雄或它的超能力发生了非实质性改变时，我们就往日志中写一条特殊的消息。 这样你可以看到DoCheck被调用的频率。结果非常显眼：

DoCheck
虽然ngDoCheck()钩子可以可以监测到英雄的name什么时候发生了变化。但我们必须小心。 这个ngDoCheck钩子被非常频繁的调用 —— 在每次变更检测周期之后，发生了变化的每个地方都会调它。 在这个例子中，用户还没有做任何操作之前，它就被调用了超过二十次。

大部分检查的第一次调用都是在Angular首次渲染该页面中其它不相关数据时触发的。 仅仅把鼠标移到其它<input>中就会触发一次调用。 只有相对较少的调用才是由于对相关数据的修改而触发的。 显然，我们的实现必须非常轻量级，否则将损害用户体验。

我们还看到，ngOnChanges方法的调用方式与API文档中是不一样的，这是因为API文档过时了。 (译注：这是经过与官方开发组沟通得到的消息，由于代码快速迭代，因此API文档现在的更新不够及时，将来会进行一次系统的梳理和更正)
AfterView

AfterView例子展示了AfterViewInit()和AfterViewChecked()钩子，Angular会在每次创建了组件的子视图后调用它们。

下面是一个子视图，它用来把英雄的名字显示在一个<input>中：

ChildComponent
Copy Code
@Component({
  selector: 'my-child-view',
  template: '<input [(ngModel)]="hero">'
})
export class ChildViewComponent {
  hero = 'Magneta';
}
AfterViewComponent把这个子视图显示在它的模板中：

AfterViewComponent (template)
Copy Code
template: `
  <div>-- child view begins --</div>
    <my-child-view></my-child-view>
  <div>-- child view ends --</div>`
下列钩子基于子视图中的每一次数据变更采取行动，我们只能通过带@ViewChild装饰器的属性来访问子视图。

AfterViewComponent (class excerpts)
Copy Code
export class AfterViewComponent implements  AfterViewChecked, AfterViewInit {
  private prevHero = '';

  // Query for a VIEW child of type `ChildViewComponent`
  @ViewChild(ChildViewComponent) viewChild: ChildViewComponent;

  ngAfterViewInit() {
    // viewChild is set after the view has been initialized
    this.logIt('AfterViewInit');
    this.doSomething();
  }

  ngAfterViewChecked() {
    // viewChild is updated after the view has been checked
    if (this.prevHero === this.viewChild.hero) {
      this.logIt('AfterViewChecked (no change)');
    } else {
      this.prevHero = this.viewChild.hero;
      this.logIt('AfterViewChecked');
      this.doSomething();
    }
  }
  // ...
}
遵循单向数据流规则
当英雄的名字超过10个字符时，doSomething()方法就会更新屏幕。

AfterViewComponent (doSomething)
Copy Code
// This surrogate for real business logic sets the `comment`
private doSomething() {
  let c = this.viewChild.hero.length > 10 ? `That's a long name` : '';
  if (c !== this.comment) {
    // Wait a tick because the component's view has already been checked
    this.logger.tick_then(() => this.comment = c);
  }
}
为什么在更新comment属性之前，doSomething()方法要等上一拍(tick)？

Angular的“单向数据流”规则禁止在一个视图已经被组合好之后再更新视图。 而这两个钩子都是在组件的视图已经被组合好之后触发的。

如果我们立即更新组件中被绑定的comment属性，Angular就会抛出一个错误(试试!)。 LoggerService.tick_then()方法延迟更新日志一个回合（浏览器JavaScript周期回合），这样就够了。

这里是AfterView的操作演示：

AfterView
注意，Angular会频繁的调用AfterViewChecked()，甚至在并没有需要关注的更改时也会触发。 所以务必把这个钩子方法写得尽可能精简，以免出现性能问题。

AfterContent

AfterContent例子展示了AfterContentInit()和AfterContentChecked()钩子，Angular会在外来内容被投影到组件中之后调用它们。

内容投影
内容投影是从组件外部导入HTML内容，并把它插入在组件模板中指定位置上的一种途径。

AngularJS的开发者大概知道一项叫做transclusion的技术，对，这就是它的马甲。
对比前一个例子考虑这个变化。 这次，我们不再通过模板来把子视图包含进来，而是改从AfterContentComponent的父组件中导入它。下面是父组件的模板：

AfterContentParentComponent (template excerpt)
Copy Code
`<after-content>
   <my-child></my-child>
 </after-content>`
注意，<my-child>标签被包含在<after-content>标签中。 永远不要在组件标签的内部放任何内容 —— 除非我们想把这些内容投影进这个组件中。

现在来看下<after-content>组件的模板：

AfterContentComponent (template)
Copy Code
template: `
  <div>-- projected content begins --</div>
    <ng-content></ng-content>
  <div>-- projected content ends --</div>`
<ng-content>标签是外来内容的占位符。 它告诉Angular在哪里插入这些外来内容。 在这里，被投影进去的内容就是来自父组件的<my-child>标签。

Projected Content
下列迹象表明存在着内容投影：
在组件的元素标签中有HTML
组件的模板中出现了<ng-content>标签
AfterContent钩子
AfterContent钩子和AfterView相似。关键的不同点是子组件的类型不同。

AfterView钩子所关心的是ViewChildren，这些子组件的元素标签会出现在该组件的模板里面。
AfterContent钩子所关心的是ContentChildren，这些子组件被Angular投影进该组件中。
下列AfterContent钩子基于子级内容中值的变化而采取相应的行动，这里我们只能通过带有@ContentChild装饰器的属性来查询到“子级内容”。

AfterContentComponent (class excerpts)
Copy Code
export class AfterContentComponent implements AfterContentChecked, AfterContentInit {
  private prevHero = '';
  comment = '';

  // Query for a CONTENT child of type `ChildComponent`
  @ContentChild(ChildComponent) contentChild: ChildComponent;

  ngAfterContentInit() {
    // contentChild is set after the content has been initialized
    this.logIt('AfterContentInit');
    this.doSomething();
  }

  ngAfterContentChecked() {
    // contentChild is updated after the content has been checked
    if (this.prevHero === this.contentChild.hero) {
      this.logIt('AfterContentChecked (no change)');
    } else {
      this.prevHero = this.contentChild.hero;
      this.logIt('AfterContentChecked');
      this.doSomething();
    }
  }
  // ...
}
使用AfterContent时，无需担心单向数据流规则
该组件的doSomething()方法立即更新了组件被绑定的comment属性。 它不用等下一回合。

回忆一下，Angular在每次调用AfterView钩子之前也会同时调用AfterContent。 Angular在完成当前组件的视图合成之前，就已经完成了被投影内容的合成。 所以我们仍然有机会去修改那个视图。

资源库

关于
书籍与培训
工具与库
社区
宣传资料
帮助

Stack Overflow
Gitter
Google Group
报告问题
网站反馈
社区

会议
Meetups
Twitter
GitHub
做贡献
其它语种

英文版
Powered by Google ©2010-2017。代码授权方式：MIT-style License。文档授权方式：CC BY 4.0。
本网站由洛阳永欣维护  豫ICP备16019859号-1